//
// Logger.h
//
// $Id: //poco/1.4/Foundation/include/Poco/Logger.h#5 $
//
// Library: Foundation
// Package: Logging
// Module:  Logger
//
// Definition of the Logger class.
//
// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier:	BSL-1.0
//


#ifndef Foundation_Logger_INCLUDED
#define Foundation_Logger_INCLUDED


#include "Poco/Foundation.h"
#include "Poco/Channel.h"
#include "Poco/Format.h"
#include "Poco/LoggerPriority.h"
#include "Poco/Thread.h"
#include <map>
#include <vector>
#include <cstddef>
#include <list>

namespace Poco {

class Exception;

struct LogMsg
{
	string			m_msg;
	LogPriority     m_priority;
	string			m_file;
	int				m_line;
	LogMsg():m_priority(LOG_TRACE),m_line(-1)
	{}
	LogMsg(const string& msg,LogPriority prio,const char* file,int line):
	m_msg(msg),m_priority(prio),m_line(line)
	{
		if (file != NULL)
		{
			m_file.append(file);
		}
	}
	
	LogMsg(const string& msg,LogPriority prio,const string& file,int line):
	m_msg(msg),m_priority(prio),m_file(file),m_line(line)
	{}
};

/// : public Channel
class Foundation_API Logger:public Runnable
	/// Logger is a special Channel that acts as the main
	/// entry point into the logging framework.
	///
	/// An application uses instances of the Logger class to generate its log messages
	/// and send them on their way to their final destination. Logger instances
	/// are organized in a hierarchical, tree-like manner and are maintained by
	/// the framework. Every Logger object has exactly one direct ancestor, with
	/// the exception of the root logger. A newly created logger inherits its properties -
	/// channel and level - from its direct ancestor. Every logger is connected
	/// to a channel, to which it passes on its messages. Furthermore, every logger
	/// has a log level, which is used for filtering messages based on their priority.
	/// Only messages with a priority equal to or higher than the specified level
	/// are passed on. For example, if the level of a logger is set to three (LOG_ERROR),
	/// only messages with priority LOG_ERROR, LOG_CRITICAL and LOG_FATAL will
	/// propagate. If the level is set to zero, the logger is effectively disabled.
	///
	/// The name of a logger determines the logger's place within the logger hierarchy.
	/// The name of the root logger is always "", the empty string. For all other
	/// loggers, the name is made up of one or more components, separated by a period.
	/// For example, the loggers with the name HTTPServer.RequestHandler and HTTPServer.Listener
	/// are descendants of the logger HTTPServer, which itself is a descendant of
	/// the root logger. There is not limit as to how deep
	/// the logger hierarchy can become. Once a logger has been created and it has
	/// inherited the channel and level from its ancestor, it loses the connection
	/// to it. So changes to the level or channel of a logger do not affect its
	/// descendants. This greatly simplifies the implementation of the framework
	/// and is no real restriction, because almost always levels and channels are
	/// set up at application startup and never changed afterwards. Nevertheless,
	/// there are methods to simultaneously change the level and channel of all
	/// loggers in a certain hierarchy.
	///
	/// There are also convenience macros available that wrap the actual
	/// logging statement into a check whether the Logger's log level
	/// is sufficient to actually log the message. This allows to increase
	/// the application performance if many complex log statements
	/// are used. The macros also add the source file path and line
	/// number into the log message so that it is available to formatters.
	/// Variants of these macros that allow message formatting with Poco::format()
	/// are also available. Up to four arguments are supported.
	///
	/// Examples:
	///     poco_warning(logger, "This is a warning");
	///     poco_information_f2(logger, "An informational message with args: %d, %d", 1, 2);
{
public:
    
	const std::string& name() const;
		/// Returns the name of the logger, which is set as the
		/// message source on all messages created by the logger.

	void setChannel(Channel* pChannel);
		/// Attaches the given Channel to the Logger.
		
	Channel* getChannel() const;
		/// Returns the Channel attached to the logger.
		
	int getLevel() const;
		/// Returns the Logger's log level.
    
	void setLevel(int level);
	void setLevel(const std::string& level);
		/// Sets the Logger's log level using a symbolic value.
		///
		/// Valid values are:
		///   - none (turns off logging)
		///   - fatal
		///   - critical
		///   - error
		///   - warning
		///   - notice
		///   - information
		///   - debug
		///   - trace
    void log(const Exception& exc);
    void log(const Exception& exc, const char* file, int line);
	
	void log(const string& msg,LogPriority prio);
		/// Logs the given message to the channel. Must be
		/// overridden by subclasses.
		///
		/// If the channel has not been opened yet, the log()
		/// method will open it.
		/// Used for CorlorConsoleChannel and FileChannel
	
    void log(const string& msg,LogPriority prio,const char* file,int line);
        /// Logs the given message to the channel. Must be
        /// overridden by subclasses.
        ///
        /// If the channel has not been opened yet, the log()
        /// method will open it.
		/// Only for FileChannel
    /*
    virtual void setProperty(const std::string& name, const std::string& value);
        /// Sets or changes a configuration property.，继承的纯虚函数，用不到，先不管
        ///
        /// Only the "channel" and "level" properties are supported, which allow
        /// setting the target channel and log level, respectively, via the LoggingRegistry.
        /// The "channel" and "level" properties are set-only.
    
    virtual std::string getProperty(const std::string& name);
    
    virtual void log(const string& name,const string& msg,LogPriority prio);
        /// Logs the given message to the channel. Must be
        /// overridden by subclasses.
        ///
        /// If the channel has not been opened yet, the log()
        /// method will open it.
        
    virtual void log(const string& name,const string& msg,LogPriority prio,const char* file,int line);
        /// Logs the given message to the channel. Must be
        /// overridden by subclasses.
        ///
        /// If the channel has not been opened yet, the log()
        /// method will open it.
    */
	static void formatDump(std::string& message, const void* buffer, std::size_t length);
		/// Creates a hex-dump of the given buffer and appends it to the
		/// given message string.
		
	static void setLevel(const std::string& name, int level);
		/// Sets the given log level on all loggers that are
		/// descendants of the Logger with the given name.
		
	static void setChannel(const std::string& name, Channel* pChannel);
		/// Attaches the given Channel to all loggers that are
		/// descendants of the Logger with the given name.

	static Logger& get(const std::string& name);
		/// Returns a reference to the Logger with the given name.
		/// If the Logger does not yet exist, it is created, based
		/// on its parent logger.

	static Logger& unsafeGet(const std::string& name);
		/// Returns a reference to the Logger with the given name.
		/// If the Logger does not yet exist, it is created, based
		/// on its parent logger.
		///
		/// WARNING: This method is not thread safe. You should
		/// probably use get() instead.
		/// The only time this method should be used is during
		/// program initialization, when only one thread is running.
		
	static Logger& create(const std::string& name, Channel* pChannel, int level = LOG_INFORMATION,bool usingThread=true);
		/// Creates and returns a reference to a Logger with the
		/// given name. The Logger's Channel and log level as set as
		/// specified.
		
	static Logger& root();
		/// Returns a reference to the root logger, which is the ultimate
		/// ancestor of all Loggers.
		
	static Logger* has(const std::string& name);
		/// Returns a pointer to the Logger with the given name if it
		/// exists, or a null pointer otherwse.
		
	static void destroy(const std::string& name);
		/// Destroys the logger with the specified name. Does nothing
		/// if the logger is not found.
		///
		/// After a logger has been destroyed, all references to it
		/// become invalid.	
		
	static void shutdown();
		/// Shuts down the logging framework and releases all
		/// Loggers.
		
	static void names(std::vector<std::string>& names);
		/// Fills the given vector with the names
		/// of all currently defined loggers.
		
	static int parseLevel(const std::string& level);
		/// Parses a symbolic log level from a string and
		/// returns the resulting numeric level.
		///
		/// Valid symbolic levels are:
		///   - none (turns off logging)
		///   - fatal
		///   - critical
		///   - error
		///   - warning
		///   - notice
		///   - information
		///   - debug
		///   - trace
		///
		/// The level is not case sensitive.
		    void fatal(const std::string& msg);
        /// If the Logger's log level is at least LOG_FATAL,
        /// creates a Message with priority LOG_FATAL
        /// and the given message text and sends it
        /// to the attached channel.
            
    /// log methods
    void fatal(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_FATAL,
        /// creates a Message with priority LOG_FATAL
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 
    template <typename ...Args>
    void fatal(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_FATAL);
    }
    
    void critical(const std::string& msg);
        /// If the Logger's log level is at least LOG_CRITICAL,
        /// creates a Message with priority LOG_CRITICAL
        /// and the given message text and sends it
        /// to the attached channel.

    void critical(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_CRITICAL,
        /// creates a Message with priority LOG_CRITICAL
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 

    template <typename ...Args>
    void critical(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_CRITICAL);
    }
    
    void error(const std::string& msg);
        /// If the Logger's log level is at least LOG_ERROR,
        /// creates a Message with priority LOG_ERROR
        /// and the given message text and sends it
        /// to the attached channel.

    void error(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_ERROR,
        /// creates a Message with priority LOG_ERROR
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 
    template <typename ...Args>
    void error(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_ERROR);
    }
    
    void warning(const std::string& msg);
        /// If the Logger's log level is at least LOG_WARNING,
        /// creates a Message with priority LOG_WARNING
        /// and the given message text and sends it
        /// to the attached channel.

    void warning(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_WARNING,
        /// creates a Message with priority LOG_WARNING
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 
    template <typename ...Args>
    void warning(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_WARNING);
    }

    void notice(const std::string& msg);
        /// If the Logger's log level is at least LOG_NOTICE,
        /// creates a Message with priority LOG_NOTICE
        /// and the given message text and sends it
        /// to the attached channel.

    void notice(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_NOTICE,
        /// creates a Message with priority LOG_NOTICE
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 
    template <typename ...Args>
    void notice(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_NOTICE);
    }
    
    void information(const std::string& msg);
        /// If the Logger's log level is at least LOG_INFORMATION,
        /// creates a Message with priority LOG_INFORMATION
        /// and the given message text and sends it
        /// to the attached channel.

    void information(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_INFORMATION,
        /// creates a Message with priority LOG_INFORMATION
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 

    template <typename ...Args>
    void information(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_INFORMATION);
    }
    
    void debug(const std::string& msg);
        /// If the Logger's log level is at least LOG_DEBUG,
        /// creates a Message with priority LOG_DEBUG
        /// and the given message text and sends it
        /// to the attached channel.

    void debug(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_DEBUG,
        /// creates a Message with priority LOG_DEBUG
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 
    template <typename ...Args>
    void debug(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_DEBUG);
    }
    
    void trace(const std::string& msg);
        /// If the Logger's log level is at least LOG_TRACE,
        /// creates a Message with priority LOG_TRACE
        /// and the given message text and sends it
        /// to the attached channel.

    void trace(const std::string& msg, const char* file, int line);
        /// If the Logger's log level is at least LOG_TRACE,
        /// creates a Message with priority LOG_TRACE
        /// and the given message text and sends it
        /// to the attached channel.
        ///
        /// File must be a static string, such as the value of
        /// the __FILE__ macro. The string is not copied
        /// internally for performance reasons. 
    template <typename ...Args>
    void trace(const std::string& fmt, Args...args)
    {
        string  msg = Poco::format(fmt,args...);
        log(msg,LOG_TRACE);
    }
    
    void dump(const std::string& msg, const void* buffer, std::size_t length, LogPriority prio = LOG_DEBUG);
        /// Logs the given message, followed by the data in buffer.
        ///
        /// The data in buffer is written in canonical hex+ASCII form:
        /// Offset (4 bytes) in hexadecimal, followed by sixteen 
        /// space-separated, two column, hexadecimal bytes,
        /// followed by the same sixteen bytes as ASCII characters.
        /// For bytes outside the range 32 .. 127, a dot is printed.

    bool is(int level) const;
        /// Returns true if at least the given log level is set.
        
    bool fatal() const;
        /// Returns true if the log level is at least LOG_FATAL.
        
    bool critical() const;
        /// Returns true if the log level is at least LOG_CRITICAL.

    bool error() const;
        /// Returns true if the log level is at least LOG_ERROR.

    bool warning() const;
        /// Returns true if the log level is at least LOG_WARNING.

    bool notice() const;
        /// Returns true if the log level is at least LOG_NOTICE.

    bool information() const;
        /// Returns true if the log level is at least LOG_INFORMATION.

    bool debug() const;
        /// Returns true if the log level is at least LOG_DEBUG.

    bool trace() const;
        /// Returns true if the log level is at least LOG_TRACE.
	static const std::string ROOT; /// The name of the root logger ("").	
		
protected:
	typedef std::map<std::string, Logger*> LoggerMap;
	// void log(const string& msg);
	Logger(const std::string& name, Channel* pChannel, int level,bool usingThread=false);
	~Logger();

	static Logger& parent(const std::string& name);
	static void add(Logger* pLogger);
	static Logger* find(const std::string& name);
	virtual void run();
	void logWayDispath(const std::string& msg,LogPriority prio, const char* file=NULL, int line=-1);
private:
	Logger();
	Logger(const Logger&);
	Logger& operator = (const Logger&);
	
	std::string         m_name;
	Channel*            m_pChannel;
	int                 m_level;

	static LoggerMap*   m_pLoggerMap;
	static Mutex        m_mapMtx;
	
	bool				m_threadOn;
	bool				m_running;
	Mutex				m_msgQueueMutex;
	Thread				m_thread;
	std::list<LogMsg>* 	m_writeQueue;
	std::list<LogMsg>* 	m_cacheQueue;	
};


//
// convenience macros
//

#define poco_fatal(logger, msg) \
    if ((logger).fatal()) (logger).fatal(msg, __FILE__, __LINE__); else (void) 0
        
#define poco_fatal_fmt(logger, fmt, ...) \
	if ((logger).fatal()) (logger).fatal(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0

#define poco_critical(logger, msg) \
	if ((logger).critical()) (logger).critical(msg, __FILE__, __LINE__); else (void) 0

#define poco_critical_fmt(logger, fmt, ...) \
	if ((logger).critical()) (logger).critical(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0

#define poco_error(logger, msg) \
	if ((logger).error()) (logger).error(msg, __FILE__, __LINE__); else (void) 0

#define poco_error_fmt(logger, fmt, ...) \
	if ((logger).error()) (logger).error(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0


#define poco_warning(logger, msg) \
	if ((logger).warning()) (logger).warning(msg, __FILE__, __LINE__); else (void) 0

#define poco_warning_fmt(logger, fmt, ...) \
	if ((logger).warning()) (logger).warning(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0


#define poco_notice(logger, msg) \
	if ((logger).notice()) (logger).notice(msg, __FILE__, __LINE__); else (void) 0

#define poco_notice_fmt(logger, fmt, ...) \
	if ((logger).notice()) (logger).notice(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0

#define poco_information(logger, msg) \
	if ((logger).information()) (logger).information(msg, __FILE__, __LINE__); else (void) 0

#define poco_information_fmt(logger, fmt, ...) \
	if ((logger).information()) (logger).information(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0


//#if defined(m_DEBUG) || defined(POCO_LOG_DEBUG)
#define poco_debug(logger, msg) \
    if ((logger).debug()) (logger).debug(msg, __FILE__, __LINE__); else (void) 0

#define poco_debug_fmt(logger, fmt, ...) \
    if ((logger).debug()) (logger).debug(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0


#define poco_trace(logger, msg) \
    if ((logger).trace()) (logger).trace(msg, __FILE__, __LINE__); else (void) 0

#define poco_trace_fmt(logger, fmt, ...) \
    if ((logger).trace()) (logger).trace(Poco::format((fmt), __VA_ARGS__), __FILE__, __LINE__); else (void) 0

// #else
// 	#define poco_debug(logger, msg)
// 	#define poco_debug_f1(logger, fmt, arg1)
// 	#define poco_debug_f2(logger, fmt, arg1, arg2)
// 	#define poco_debug_f3(logger, fmt, arg1, arg2, arg3)
// 	#define poco_debug_f4(logger, fmt, arg1, arg2, arg3, arg4)
// 	#define poco_trace(logger, msg)
// 	#define poco_trace_f1(logger, fmt, arg1)
// 	#define poco_trace_f2(logger, fmt, arg1, arg2)
// 	#define poco_trace_f3(logger, fmt, arg1, arg2, arg3)
// 	#define poco_trace_f4(logger, fmt, arg1, arg2, arg3, arg4)
// #endif


//
// inlines
//
inline const std::string& Logger::name() const
{
	return m_name;
}


inline int Logger::getLevel() const
{
	return m_level;
}

inline void Logger::log(const std::string& text, LogPriority prio)
{
	if (m_level >= prio && m_pChannel != nullptr)
	{
		m_pChannel->log(text, prio);
	}
}


inline void Logger::log(const std::string& text, LogPriority prio, const char* file, int line)
{
	if (m_level >= prio && m_pChannel != nullptr)
	{
		m_pChannel->log(text, prio, file, line);
	}
}

inline void Logger::logWayDispath(const std::string& msg,LogPriority prio, const char* file, int line)
{
	if (m_threadOn && m_cacheQueue)
	{
		ScopedLock<Mutex> lock(m_msgQueueMutex);
		m_cacheQueue->push_back(LogMsg(msg,prio,file,line));
	}
	else
	{
		log(msg, prio);
	}
}

inline void Logger::fatal(const std::string& msg)
{
	logWayDispath(msg,LOG_FATAL);
}


inline void Logger::fatal(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_FATAL, file, line);
}


inline void Logger::critical(const std::string& msg)
{
	logWayDispath(msg,LOG_CRITICAL);
}


inline void Logger::critical(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_CRITICAL, file, line);
}


inline void Logger::error(const std::string& msg)
{
	logWayDispath(msg,LOG_ERROR);
}


inline void Logger::error(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_ERROR, file, line);
}


inline void Logger::warning(const std::string& msg)
{
	logWayDispath(msg, LOG_WARNING);
}


inline void Logger::warning(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_WARNING, file, line);
}


inline void Logger::notice(const std::string& msg)
{
	logWayDispath(msg, LOG_NOTICE);
}


inline void Logger::notice(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_NOTICE, file, line);
}

inline void Logger::information(const std::string& msg)
{
	logWayDispath(msg, LOG_INFORMATION);
}


inline void Logger::information(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_INFORMATION, file, line);
}


inline void Logger::debug(const std::string& msg)
{
	logWayDispath(msg, LOG_DEBUG);
}


inline void Logger::debug(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_DEBUG, file, line);
}

inline void Logger::trace(const std::string& msg)
{
	logWayDispath(msg, LOG_TRACE);
}


inline void Logger::trace(const std::string& msg, const char* file, int line)
{
	logWayDispath(msg, LOG_TRACE, file, line);
}

inline bool Logger::is(int level) const
{
	return m_level >= level;
}


inline bool Logger::fatal() const
{
	return m_level >= LOG_FATAL;
}


inline bool Logger::critical() const
{
	return m_level >= LOG_CRITICAL;
}


inline bool Logger::error() const
{
	return m_level >= LOG_ERROR;
}


inline bool Logger::warning() const
{
	return m_level >= LOG_WARNING;
}


inline bool Logger::notice() const
{
	return m_level >= LOG_NOTICE;
}


inline bool Logger::information() const
{
	return m_level >= LOG_INFORMATION;
}


inline bool Logger::debug() const
{
	return m_level >= LOG_DEBUG;
}


inline bool Logger::trace() const
{
	return m_level >= LOG_TRACE;
}


} // namespace Poco


#endif // Foundation_Logger_INCLUDED
